// 模糊查询函数
export function searchByKey(keyName, oldTableList, name) {
  const keyword = keyName.trim().toLowerCase();
  const results = [];
  const addedItems = new Set(); // 用于记录已添加的项
  if (keyword) {
    // 递归函数，用于遍历数组并收集匹配项及其父级和子级
    function traverse(items) {
      items.forEach((item) => {
        // 检查当前节点的 name 是否包含关键词
        if (item[name].toLowerCase().includes(keyword)) {
          // 匹配到了，将当前节点加入结果
          if (!addedItems.has(item.id)) {
            results.push(item);
            addedItems.add(item.id);

            // 如果当前节点有子级，递归处理子级
            if (item.children && item.children.length > 0) {
              traverse(item.children);
            }
          }
        } else {
          // 即使当前节点的 name 不包含关键词，也要处理其子级

          if (item.children && item.children.length > 0) {
            traverse(item.children);
          }
        }
        // 如果当前节点不是根节点且其父级已经包含在结果集中
        if (
          item.parentId !== null &&
          results.some((result) => result.id === item.parentId)
        ) {
          // 将当前节点加入结果
          if (!addedItems.has(item.id)) {
            results.push(item);
            addedItems.add(item.id);

            // 如果当前节点有子级，递归处理子级
            if (item.children && item.children.length > 0) {
              traverse(item.children);
            }
          }
        }
      });
    }

    // 开始遍历整个列表
    traverse(oldTableList);

    // 遍历结果集，确保所有匹配项的父级也被加入结果
    results.forEach((item) => {
      let parent = findParentById(item.parentId, deepCopy(oldTableList));
      while (parent && !addedItems.has(parent.id)) {
        results.push(parent);
        addedItems.add(parent.id);
        parent = findParentById(parent.parentId, deepCopy(oldTableList));
      }
    });

    // 返回结果
    return results;
  } else {
    // 修复：原代码中使用了未定义的变量 list，应该返回原始列表
    return oldTableList;
  }
}

// 辅助函数，通过 ID 查找父级
export function findParentById(id, list) {
  for (let i = 0; i < list.length; i++) {
    if (list[i].id === id) {
      return list[i];
    }
  }
  return null;
}

// 深拷贝
export function deepCopy(obj) {
  if (obj === null || typeof obj !== "object") {
    return obj;
  }

  if (obj instanceof Array) {
    const copy = [];
    for (let i = 0, len = obj.length; i < len; i++) {
      copy[i] = deepCopy(obj[i]);
    }
    return copy;
  }

  if (obj instanceof Object) {
    const copy = {};
    for (const attr in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, attr)) {
        copy[attr] = deepCopy(obj[attr]);
      }
    }
    return copy;
  }

  throw new Error("Unable to copy obj! Its type isn't supported.");
}